try/catch 个块 async/await
try/catch blocks with async/await
我正在深入研究节点 7 async/await 功能,并不断遇到这样的代码
function getQuote() {
let quote = "Lorem ipsum dolor sit amet, consectetur adipiscing elit laborum.";
return quote;
}
async function main() {
try {
var quote = await getQuote();
console.log(quote);
} catch (error) {
console.error(error);
}
}
main();
这似乎是 resolve/reject 或 return/throw 与 async/await 的唯一可能性,但是,v8 没有优化 try/catch 块内的代码?!
有其他选择吗?
备选方案
替代方案:
async function main() {
try {
var quote = await getQuote();
console.log(quote);
} catch (error) {
console.error(error);
}
}
会是这样的,明确使用承诺:
function main() {
getQuote().then((quote) => {
console.log(quote);
}).catch((error) => {
console.error(error);
});
}
或类似这样的东西,使用连续传递样式:
function main() {
getQuote((error, quote) => {
if (error) {
console.error(error);
} else {
console.log(quote);
}
});
}
原始示例
您的原始代码所做的是暂停执行并等待由 getQuote()
编辑的承诺 return 完成。然后它继续执行并将 returned 值写入 var quote
,然后如果承诺已解决则打印它,或者抛出异常并运行 catch 块以在承诺被拒绝时打印错误。
您可以像第二个示例一样直接使用 Promise API 做同样的事情。
性能
现在,为了表演。让我们测试一下!
我刚刚写了这段代码 - f1()
将 1
作为 return 值,f2()
抛出 1
作为异常:
function f1() {
return 1;
}
function f2() {
throw 1;
}
现在让我们调用相同的代码一百万次,首先是 f1()
:
var sum = 0;
for (var i = 0; i < 1e6; i++) {
try {
sum += f1();
} catch (e) {
sum += e;
}
}
console.log(sum);
然后让我们将 f1()
更改为 f2()
:
var sum = 0;
for (var i = 0; i < 1e6; i++) {
try {
sum += f2();
} catch (e) {
sum += e;
}
}
console.log(sum);
这是我 f1
:
得到的结果
$ time node throw-test.js
1000000
real 0m0.073s
user 0m0.070s
sys 0m0.004s
这是我得到的 f2
:
$ time node throw-test.js
1000000
real 0m0.632s
user 0m0.629s
sys 0m0.004s
看来你可以在一个单线程进程中每秒执行 200 万次抛出。如果你做的不止于此,那么你可能需要担心它。
总结
我不会担心 Node.js 中的那些事情。如果这样的东西被大量使用,那么它最终会被 V8 或 SpiderMonkey 或 Chakra 团队优化,并且每个人都会遵循 - 这并不是说它没有作为原则进行优化,这不是问题。
即使它没有优化,我仍然认为如果你在 Node 中最大化你的 CPU 那么你应该用 C 编写你的数字运算 - 这就是本机插件的内容对于,除其他事项外。或者 node.native 之类的东西可能比 Node.js.
更适合这份工作
我想知道需要抛出这么多异常的用例是什么。通常抛出异常而不是 returning 值是异常。
try-catch 块的替代方法是 await-to-js 库。我经常使用它。
例如:
import to from 'await-to-js';
async function main(callback) {
const [err,quote] = await to(getQuote());
if(err || !quote) return callback(new Error('No Quote found'));
callback(null,quote);
}
与 try-catch 相比,此语法更简洁。
async function main() {
var getQuoteError
var quote = await getQuote().catch(err => { getQuoteError = err }
if (getQuoteError) return console.error(err)
console.log(quote)
}
或者,您可以这样做,而不是声明一个可能的 var 来在顶部保存错误
if (quote instanceof Error) {
// ...
}
虽然如果抛出类似 TypeError 或 Reference 错误的东西,那将不起作用。您可以使用
确保这是一个常规错误
async function main() {
var quote = await getQuote().catch(err => {
console.error(err)
return new Error('Error getting quote')
})
if (quote instanceOf Error) return quote // get out of here or do whatever
console.log(quote)
}
我对此的偏好是将所有内容包装在一个大的 try-catch 块中,其中创建了多个承诺,这使得专门针对创建它的承诺处理错误变得很麻烦。替代方案是多个 try-catch 块,我发现这同样很麻烦
我想这样做:)
const sthError = () => Promise.reject('sth error');
const test = opts => {
return (async () => {
// do sth
await sthError();
return 'ok';
})().catch(err => {
console.error(err); // error will be catched there
});
};
test().then(ret => {
console.log(ret);
});
这类似于 co
的错误处理
const test = opts => {
return co(function*() {
// do sth
yield sthError();
return 'ok';
}).catch(err => {
console.error(err);
});
};
类似于 Golang 中的错误处理的替代方案
因为 async/await 在底层使用了 promises,你可以像这样写一个小实用函数:
export function catchEm(promise) {
return promise.then(data => [null, data])
.catch(err => [err]);
}
然后在您需要捕获一些错误时导入它,并包装您的异步函数,returns 一个承诺。
import catchEm from 'utility';
async performAsyncWork() {
const [err, data] = await catchEm(asyncFunction(arg1, arg2));
if (err) {
// handle errors
} else {
// use data
}
}
更简洁的替代方案如下:
由于每个异步函数在技术上都是一个承诺
您可以在使用 await
调用函数时向函数添加捕获
async function a(){
let error;
// log the error on the parent
await b().catch((err)=>console.log('b.failed'))
// change an error variable
await c().catch((err)=>{error=true; console.log(err)})
// return whatever you want
return error ? d() : null;
}
a().catch(()=>console.log('main program failed'))
不需要try catch,因为所有的promises错误都被处理了,而且你没有代码错误,你可以在parent中省略!!
假设您正在使用 mongodb,如果出现错误,您可能更愿意在调用它的函数中处理它,而不是制作包装器或使用 try catches。
catch
根据我的经验,以这种方式进行操作很危险。整个堆栈中抛出的任何错误都将被捕获,而不仅仅是这个承诺的错误(这可能不是你想要的)。
promise 的第二个参数已经是 rejection/failure 回调。改用它更好更安全。
这是一个打字稿类型安全 one-liner 我写来处理这个问题:
function wait<R, E>(promise: Promise<R>): [R | null, E | null] {
return (promise.then((data: R) => [data, null], (err: E) => [null, err]) as any) as [R, E];
}
// Usage
const [currUser, currUserError] = await wait<GetCurrentUser_user, GetCurrentUser_errors>(
apiClient.getCurrentUser()
);
不需要像 await-to-js 这样的库,to
-函数的一个简单的一行(也显示在其他答案中)就可以了:
const to = promise => promise.then(res => [null, res]).catch(err => [err || true, null]);
用法:
async function main()
{
var [err, quote] = await to(getQuote());
if(err)
{
console.log('warn: Could not get quote.');
}
else
{
console.log(quote);
}
}
但是,如果错误导致函数或程序终止,例如:
async function main()
{
var [err, quote] = await to(getQuote());
if(err) return console.error(err);
console.log(quote);
}
那么你不妨简单地让 main() 中的错误 return 自动发生,这无论如何都是异常的预期目的:
async function main()
{
var quote = await getQuote();
console.log(quote);
}
main().catch(err => console.error('error in main():', err));
抛出错误与 return 抛出错误
如果您希望处理预期会发生的错误,那么使用 throw
或 reject
是不好的做法。相反,让 getQuote()
函数始终使用以下任何一个解析:
resolve([err, result])
resolve(null)
resolve(new Error(...))
resolve({error: new Error(), result: null})
- 等等
抛出错误(或异步中的等价物:拒绝承诺)必须保持异常。由于异常只会在事情进展顺利时发生,而在正常使用期间不应发生,因此优化不是优先事项。因此,异常的唯一结果可能是函数终止,如果无论如何都没有被捕获,这是默认行为。
除非您处理设计不佳的第 3 方库,或者您正在将第 3 方库函数用于意外用例,否则您应该不使用to
-函数。
如果是Express框架,我一般采用以下方法。我们可以创建一个解决承诺的函数。像 catchAsync
函数:
const catchAsync = (fn) => (req, res, next) =>{
Promise.resolve(fn(req, res, next)).catch((err) => next(err));
});
这个函数可以在我们需要的任何地方调用try/catch。它接收我们调用的函数,并根据所携带的动作来解析或拒绝它。我们可以这样称呼它
const sampleFunction = catchAsync(async (req, res) => {
const awaitedResponse = await getResponse();
res.send(awaitedResponse);
});
我认为,一个简单且解释清楚的例子来自How to use promises of MDN DOCS。
例如,他们使用 API Fetch 然后是 2 种类型,一种是普通类型,另一种是 hybrid,其中异步和Promise混在一起。
- 简单示例
async function myFetch() {
let response = await fetch("coffee.jpg");
// Added manually a validation and throws an error
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
let myBlob = await response.blob();
let objectURL = URL.createObjectURL(myBlob);
let image = document.createElement("img");
image.src = objectURL;
document.body.appendChild(image);
}
myFetch().catch((e) => {
// Catches the errors...
console.log("There has been a problem with your fetch operation: " + e.message);
});
- 混合方法
Since an async keyword turns a function into a promise, you could refactor your code to use a hybrid approach of promises and await, bringing the second half of the function out into a new block to make it more flexible:
async function myFetch() {
// Uses async
let response = await fetch("coffee.jpg");
// Added manually a validation and throws an error
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return await response.blob();
}
myFetch()
.then((blob) => {
// uses plain promise
let objectURL = URL.createObjectURL(blob);
let image = document.createElement("img");
image.src = objectURL;
document.body.appendChild(image);
})
.catch((e) => console.log(e));
Adding error handling
- 正常
async function myFetch() {
try {
let response = await fetch("coffee.jpg");
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
let myBlob = await response.blob();
let objectURL = URL.createObjectURL(myBlob);
let image = document.createElement("img");
image.src = objectURL;
document.body.appendChild(image);
} catch (e) {
console.log(e);
}
}
myFetch();
- 混合 (最佳)
async function myFetch() {
let response = await fetch("coffee.jpg");
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return await response.blob();
}
myFetch()
.then((blob) => {
let objectURL = URL.createObjectURL(blob);
let image = document.createElement("img");
image.src = objectURL;
document.body.appendChild(image);
})
.catch(
(
e // Not need a try catch. This will catch it all already!
) => console.log(e)
);
最佳解决方案
给出的最佳解决方案遵循这些原则但更加清晰,是这个答案 --> Whosebug:try/catch 块 async/await
我相信。这里
function promiseHandle(promise) {
return promise.then((data) => [null, data]).catch((err) => [err]);
}
async function asyncFunc(param1, param2) {
const [err, data] = await promiseHandle(expensiveFunction(param1, param2));
// This just to show, that in this way we can control what is going on..
if (err || !data) {
if (err) return Promise.reject(`Error but not data..`);
return Promise.reject(`Error but not data..`);
}
return Promise.resolve(data);
}
我正在深入研究节点 7 async/await 功能,并不断遇到这样的代码
function getQuote() {
let quote = "Lorem ipsum dolor sit amet, consectetur adipiscing elit laborum.";
return quote;
}
async function main() {
try {
var quote = await getQuote();
console.log(quote);
} catch (error) {
console.error(error);
}
}
main();
这似乎是 resolve/reject 或 return/throw 与 async/await 的唯一可能性,但是,v8 没有优化 try/catch 块内的代码?!
有其他选择吗?
备选方案
替代方案:
async function main() {
try {
var quote = await getQuote();
console.log(quote);
} catch (error) {
console.error(error);
}
}
会是这样的,明确使用承诺:
function main() {
getQuote().then((quote) => {
console.log(quote);
}).catch((error) => {
console.error(error);
});
}
或类似这样的东西,使用连续传递样式:
function main() {
getQuote((error, quote) => {
if (error) {
console.error(error);
} else {
console.log(quote);
}
});
}
原始示例
您的原始代码所做的是暂停执行并等待由 getQuote()
编辑的承诺 return 完成。然后它继续执行并将 returned 值写入 var quote
,然后如果承诺已解决则打印它,或者抛出异常并运行 catch 块以在承诺被拒绝时打印错误。
您可以像第二个示例一样直接使用 Promise API 做同样的事情。
性能
现在,为了表演。让我们测试一下!
我刚刚写了这段代码 - f1()
将 1
作为 return 值,f2()
抛出 1
作为异常:
function f1() {
return 1;
}
function f2() {
throw 1;
}
现在让我们调用相同的代码一百万次,首先是 f1()
:
var sum = 0;
for (var i = 0; i < 1e6; i++) {
try {
sum += f1();
} catch (e) {
sum += e;
}
}
console.log(sum);
然后让我们将 f1()
更改为 f2()
:
var sum = 0;
for (var i = 0; i < 1e6; i++) {
try {
sum += f2();
} catch (e) {
sum += e;
}
}
console.log(sum);
这是我 f1
:
$ time node throw-test.js
1000000
real 0m0.073s
user 0m0.070s
sys 0m0.004s
这是我得到的 f2
:
$ time node throw-test.js
1000000
real 0m0.632s
user 0m0.629s
sys 0m0.004s
看来你可以在一个单线程进程中每秒执行 200 万次抛出。如果你做的不止于此,那么你可能需要担心它。
总结
我不会担心 Node.js 中的那些事情。如果这样的东西被大量使用,那么它最终会被 V8 或 SpiderMonkey 或 Chakra 团队优化,并且每个人都会遵循 - 这并不是说它没有作为原则进行优化,这不是问题。
即使它没有优化,我仍然认为如果你在 Node 中最大化你的 CPU 那么你应该用 C 编写你的数字运算 - 这就是本机插件的内容对于,除其他事项外。或者 node.native 之类的东西可能比 Node.js.
更适合这份工作我想知道需要抛出这么多异常的用例是什么。通常抛出异常而不是 returning 值是异常。
try-catch 块的替代方法是 await-to-js 库。我经常使用它。 例如:
import to from 'await-to-js';
async function main(callback) {
const [err,quote] = await to(getQuote());
if(err || !quote) return callback(new Error('No Quote found'));
callback(null,quote);
}
与 try-catch 相比,此语法更简洁。
async function main() {
var getQuoteError
var quote = await getQuote().catch(err => { getQuoteError = err }
if (getQuoteError) return console.error(err)
console.log(quote)
}
或者,您可以这样做,而不是声明一个可能的 var 来在顶部保存错误
if (quote instanceof Error) {
// ...
}
虽然如果抛出类似 TypeError 或 Reference 错误的东西,那将不起作用。您可以使用
确保这是一个常规错误async function main() {
var quote = await getQuote().catch(err => {
console.error(err)
return new Error('Error getting quote')
})
if (quote instanceOf Error) return quote // get out of here or do whatever
console.log(quote)
}
我对此的偏好是将所有内容包装在一个大的 try-catch 块中,其中创建了多个承诺,这使得专门针对创建它的承诺处理错误变得很麻烦。替代方案是多个 try-catch 块,我发现这同样很麻烦
我想这样做:)
const sthError = () => Promise.reject('sth error');
const test = opts => {
return (async () => {
// do sth
await sthError();
return 'ok';
})().catch(err => {
console.error(err); // error will be catched there
});
};
test().then(ret => {
console.log(ret);
});
这类似于 co
const test = opts => {
return co(function*() {
// do sth
yield sthError();
return 'ok';
}).catch(err => {
console.error(err);
});
};
类似于 Golang 中的错误处理的替代方案
因为 async/await 在底层使用了 promises,你可以像这样写一个小实用函数:
export function catchEm(promise) {
return promise.then(data => [null, data])
.catch(err => [err]);
}
然后在您需要捕获一些错误时导入它,并包装您的异步函数,returns 一个承诺。
import catchEm from 'utility';
async performAsyncWork() {
const [err, data] = await catchEm(asyncFunction(arg1, arg2));
if (err) {
// handle errors
} else {
// use data
}
}
更简洁的替代方案如下:
由于每个异步函数在技术上都是一个承诺
您可以在使用 await
调用函数时向函数添加捕获async function a(){
let error;
// log the error on the parent
await b().catch((err)=>console.log('b.failed'))
// change an error variable
await c().catch((err)=>{error=true; console.log(err)})
// return whatever you want
return error ? d() : null;
}
a().catch(()=>console.log('main program failed'))
不需要try catch,因为所有的promises错误都被处理了,而且你没有代码错误,你可以在parent中省略!!
假设您正在使用 mongodb,如果出现错误,您可能更愿意在调用它的函数中处理它,而不是制作包装器或使用 try catches。
catch
根据我的经验,以这种方式进行操作很危险。整个堆栈中抛出的任何错误都将被捕获,而不仅仅是这个承诺的错误(这可能不是你想要的)。
promise 的第二个参数已经是 rejection/failure 回调。改用它更好更安全。
这是一个打字稿类型安全 one-liner 我写来处理这个问题:
function wait<R, E>(promise: Promise<R>): [R | null, E | null] {
return (promise.then((data: R) => [data, null], (err: E) => [null, err]) as any) as [R, E];
}
// Usage
const [currUser, currUserError] = await wait<GetCurrentUser_user, GetCurrentUser_errors>(
apiClient.getCurrentUser()
);
不需要像 await-to-js 这样的库,to
-函数的一个简单的一行(也显示在其他答案中)就可以了:
const to = promise => promise.then(res => [null, res]).catch(err => [err || true, null]);
用法:
async function main()
{
var [err, quote] = await to(getQuote());
if(err)
{
console.log('warn: Could not get quote.');
}
else
{
console.log(quote);
}
}
但是,如果错误导致函数或程序终止,例如:
async function main()
{
var [err, quote] = await to(getQuote());
if(err) return console.error(err);
console.log(quote);
}
那么你不妨简单地让 main() 中的错误 return 自动发生,这无论如何都是异常的预期目的:
async function main()
{
var quote = await getQuote();
console.log(quote);
}
main().catch(err => console.error('error in main():', err));
抛出错误与 return 抛出错误
如果您希望处理预期会发生的错误,那么使用 throw
或 reject
是不好的做法。相反,让 getQuote()
函数始终使用以下任何一个解析:
resolve([err, result])
resolve(null)
resolve(new Error(...))
resolve({error: new Error(), result: null})
- 等等
抛出错误(或异步中的等价物:拒绝承诺)必须保持异常。由于异常只会在事情进展顺利时发生,而在正常使用期间不应发生,因此优化不是优先事项。因此,异常的唯一结果可能是函数终止,如果无论如何都没有被捕获,这是默认行为。
除非您处理设计不佳的第 3 方库,或者您正在将第 3 方库函数用于意外用例,否则您应该不使用to
-函数。
如果是Express框架,我一般采用以下方法。我们可以创建一个解决承诺的函数。像 catchAsync
函数:
const catchAsync = (fn) => (req, res, next) =>{
Promise.resolve(fn(req, res, next)).catch((err) => next(err));
});
这个函数可以在我们需要的任何地方调用try/catch。它接收我们调用的函数,并根据所携带的动作来解析或拒绝它。我们可以这样称呼它
const sampleFunction = catchAsync(async (req, res) => {
const awaitedResponse = await getResponse();
res.send(awaitedResponse);
});
我认为,一个简单且解释清楚的例子来自How to use promises of MDN DOCS。
例如,他们使用 API Fetch 然后是 2 种类型,一种是普通类型,另一种是 hybrid,其中异步和Promise混在一起。
- 简单示例
async function myFetch() {
let response = await fetch("coffee.jpg");
// Added manually a validation and throws an error
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
let myBlob = await response.blob();
let objectURL = URL.createObjectURL(myBlob);
let image = document.createElement("img");
image.src = objectURL;
document.body.appendChild(image);
}
myFetch().catch((e) => {
// Catches the errors...
console.log("There has been a problem with your fetch operation: " + e.message);
});
- 混合方法
Since an async keyword turns a function into a promise, you could refactor your code to use a hybrid approach of promises and await, bringing the second half of the function out into a new block to make it more flexible:
async function myFetch() {
// Uses async
let response = await fetch("coffee.jpg");
// Added manually a validation and throws an error
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return await response.blob();
}
myFetch()
.then((blob) => {
// uses plain promise
let objectURL = URL.createObjectURL(blob);
let image = document.createElement("img");
image.src = objectURL;
document.body.appendChild(image);
})
.catch((e) => console.log(e));
Adding error handling
- 正常
async function myFetch() {
try {
let response = await fetch("coffee.jpg");
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
let myBlob = await response.blob();
let objectURL = URL.createObjectURL(myBlob);
let image = document.createElement("img");
image.src = objectURL;
document.body.appendChild(image);
} catch (e) {
console.log(e);
}
}
myFetch();
- 混合 (最佳)
async function myFetch() {
let response = await fetch("coffee.jpg");
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
return await response.blob();
}
myFetch()
.then((blob) => {
let objectURL = URL.createObjectURL(blob);
let image = document.createElement("img");
image.src = objectURL;
document.body.appendChild(image);
})
.catch(
(
e // Not need a try catch. This will catch it all already!
) => console.log(e)
);
最佳解决方案
给出的最佳解决方案遵循这些原则但更加清晰,是这个答案 --> Whosebug:try/catch 块 async/await 我相信。这里
function promiseHandle(promise) {
return promise.then((data) => [null, data]).catch((err) => [err]);
}
async function asyncFunc(param1, param2) {
const [err, data] = await promiseHandle(expensiveFunction(param1, param2));
// This just to show, that in this way we can control what is going on..
if (err || !data) {
if (err) return Promise.reject(`Error but not data..`);
return Promise.reject(`Error but not data..`);
}
return Promise.resolve(data);
}